home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Python 1.3.3 / pbmplus / libtiff / tif_dirread.c < prev    next >
Text File  |  1996-02-28  |  35KB  |  1,249 lines
  1. #ifndef lint
  2. static char rcsid[] = "$Header: /usr/people/sam/tiff/libtiff/RCS/tif_dirread.c,v 1.43 93/08/26 14:23:18 sam Exp $";
  3. #endif
  4.  
  5. /*
  6.  * Copyright (c) 1988, 1989, 1990, 1991, 1992 Sam Leffler
  7.  * Copyright (c) 1991, 1992 Silicon Graphics, Inc.
  8.  *
  9.  * Permission to use, copy, modify, distribute, and sell this software and 
  10.  * its documentation for any purpose is hereby granted without fee, provided
  11.  * that (i) the above copyright notices and this permission notice appear in
  12.  * all copies of the software and related documentation, and (ii) the names of
  13.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  14.  * publicity relating to the software without the specific, prior written
  15.  * permission of Sam Leffler and Silicon Graphics.
  16.  * 
  17.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  18.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  19.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  20.  * 
  21.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  22.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  23.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  24.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  25.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  26.  * OF THIS SOFTWARE.
  27.  */
  28.  
  29. /*
  30.  * TIFF Library.
  31.  *
  32.  * Directory Read Support Routines.
  33.  */
  34. #include "tiffiop.h"
  35.  
  36. #define    IGNORE    0        /* tag placeholder used below */
  37.  
  38. #if HAVE_IEEEFP
  39. #define    TIFFCvtIEEEFloatToNative(tif, n, fp)
  40. #endif
  41.  
  42. static    void EstimateStripByteCounts(TIFF*, TIFFDirEntry*, uint16);
  43. static    void MissingRequired(TIFF*, const char*);
  44. static    int CheckDirCount(TIFF*, TIFFDirEntry*, uint32);
  45. static    tsize_t TIFFFetchData(TIFF*, TIFFDirEntry*, char*);
  46. static    tsize_t TIFFFetchString(TIFF*, TIFFDirEntry*, char*);
  47. static    float TIFFFetchRational(TIFF*, TIFFDirEntry*);
  48. static    int TIFFFetchNormalTag(TIFF*, TIFFDirEntry*);
  49. static    int TIFFFetchPerSampleShorts(TIFF*, TIFFDirEntry*, int*);
  50. static    int TIFFFetchShortArray(TIFF*, TIFFDirEntry*, uint16*);
  51. static    int TIFFFetchStripThing(TIFF*, TIFFDirEntry*, long, uint32**);
  52. static    int TIFFFetchExtraSamples(TIFF*, TIFFDirEntry*);
  53. static    int TIFFFetchRefBlackWhite(TIFF*, TIFFDirEntry*);
  54. static    int TIFFFetchJPEGQTables(TIFF*, TIFFDirEntry*);
  55. static    int TIFFFetchJPEGCTables(TIFF*, TIFFDirEntry*, u_char***);
  56. static    float TIFFFetchFloat(TIFF*, TIFFDirEntry*);
  57. static    int TIFFFetchFloatArray(TIFF*, TIFFDirEntry*, float*);
  58. static    int TIFFFetchShortPair(TIFF*, TIFFDirEntry*);
  59. #ifdef STRIPCHOP_SUPPORT
  60. static    void ChopUpSingleUncompressedStrip(TIFF*);
  61. #endif
  62.  
  63. static char *
  64. CheckMalloc(TIFF* tif, size_t n, const char* what)
  65. {
  66.     char *cp = _TIFFmalloc(n);
  67.     if (cp == NULL)
  68.         TIFFError(tif->tif_name, "No space %s", what);
  69.     return (cp);
  70. }
  71.  
  72. /*
  73.  * Read the next TIFF directory from a file
  74.  * and convert it to the internal format.
  75.  * We read directories sequentially.
  76.  */
  77. int
  78. TIFFReadDirectory(TIFF* tif)
  79. {
  80.     register TIFFDirEntry *dp;
  81.     register int n;
  82.     register TIFFDirectory *td;
  83.     TIFFDirEntry *dir;
  84.     int iv;
  85.     long v;
  86.     const TIFFFieldInfo *fip;
  87.     uint16 dircount;
  88.     uint32 nextdiroff;
  89.     char *cp;
  90.     int diroutoforderwarning = 0;
  91.  
  92.     tif->tif_diroff = tif->tif_nextdiroff;
  93.     if (tif->tif_diroff == 0)        /* no more directories */
  94.         return (0);
  95.     /*
  96.      * Cleanup any previous compression state.
  97.      */
  98.     if (tif->tif_cleanup)
  99.         (*tif->tif_cleanup)(tif);
  100.     tif->tif_curdir++;
  101.     nextdiroff = 0;
  102.     if (!isMapped(tif)) {
  103.         if (!SeekOK(tif, tif->tif_diroff)) {
  104.             TIFFError(tif->tif_name,
  105.                 "Seek error accessing TIFF directory");
  106.             return (0);
  107.         }
  108.         if (!ReadOK(tif, &dircount, sizeof (uint16))) {
  109.             TIFFError(tif->tif_name,
  110.                 "Can not read TIFF directory count");
  111.             return (0);
  112.         }
  113.         if (tif->tif_flags & TIFF_SWAB)
  114.             TIFFSwabShort(&dircount);
  115.         dir = (TIFFDirEntry *)CheckMalloc(tif,
  116.             dircount * sizeof (TIFFDirEntry), "to read TIFF directory");
  117.         if (dir == NULL)
  118.             return (0);
  119.         if (!ReadOK(tif, dir, dircount*sizeof (TIFFDirEntry))) {
  120.             TIFFError(tif->tif_name, "Can not read TIFF directory");
  121.             goto bad;
  122.         }
  123.         /*
  124.          * Read offset to next directory for sequential scans.
  125.          */
  126.         (void) ReadOK(tif, &nextdiroff, sizeof (uint32));
  127.     } else {
  128.         toff_t off = tif->tif_diroff;
  129.  
  130.         if (off + sizeof (short) > tif->tif_size) {
  131.             TIFFError(tif->tif_name,
  132.                 "Can not read TIFF directory count");
  133.             return (0);
  134.         } else
  135.             memcpy(&dircount, tif->tif_base + off, sizeof (uint16));
  136.         off += sizeof (uint16);
  137.         if (tif->tif_flags & TIFF_SWAB)
  138.             TIFFSwabShort(&dircount);
  139.         dir = (TIFFDirEntry *)CheckMalloc(tif,
  140.             dircount * sizeof (TIFFDirEntry), "to read TIFF directory");
  141.         if (dir == NULL)
  142.             return (0);
  143.         if (off + dircount*sizeof (TIFFDirEntry) > tif->tif_size) {
  144.             TIFFError(tif->tif_name, "Can not read TIFF directory");
  145.             goto bad;
  146.         } else
  147.             memcpy(dir, tif->tif_base + off,
  148.                 dircount*sizeof (TIFFDirEntry));
  149.         off += dircount* sizeof (TIFFDirEntry);
  150.         if (off + sizeof (uint32) < tif->tif_size)
  151.             memcpy(&nextdiroff, tif->tif_base+off, sizeof (uint32));
  152.     }
  153.     if (tif->tif_flags & TIFF_SWAB)
  154.         TIFFSwabLong(&nextdiroff);
  155.     tif->tif_nextdiroff = nextdiroff;
  156.  
  157.     tif->tif_flags &= ~TIFF_BEENWRITING;    /* reset before new dir */
  158.     /*
  159.      * Setup default value and then make a pass over
  160.      * the fields to check type and tag information,
  161.      * and to extract info required to size data
  162.      * structures.  A second pass is made afterwards
  163.      * to read in everthing not taken in the first pass.
  164.      */
  165.     td = &tif->tif_dir;
  166.     /* free any old stuff and reinit */
  167.     TIFFFreeDirectory(tif);
  168.     TIFFDefaultDirectory(tif);
  169.     tif->tif_postdecode = TIFFNoPostDecode;
  170.     /*
  171.      * Electronic Arts writes gray-scale TIFF files
  172.      * without a PlanarConfiguration directory entry.
  173.      * Thus we setup a default value here, even though
  174.      * the TIFF spec says there is no default value.
  175.      */
  176.     TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
  177.     for (fip = tiffFieldInfo, dp = dir, n = dircount; n > 0; n--, dp++) {
  178.         if (tif->tif_flags & TIFF_SWAB) {
  179.             TIFFSwabArrayOfShort(&dp->tdir_tag, 2);
  180.             TIFFSwabArrayOfLong(&dp->tdir_count, 2);
  181.         }
  182.         /*
  183.          * Find the field information entry for this tag.
  184.          */
  185.         /*
  186.          * Silicon Beach (at least) writes unordered
  187.          * directory tags (violating the spec).  Handle
  188.          * it here, but be obnoxious (maybe they'll fix it?).
  189.          */
  190.         if (dp->tdir_tag < fip->field_tag) {
  191.             if (!diroutoforderwarning) {
  192.                 TIFFWarning(tif->tif_name,
  193.     "invalid TIFF directory; tags are not sorted in ascending order");
  194.                 diroutoforderwarning = 1;
  195.             }
  196.             fip = tiffFieldInfo;    /* O(n^2) */
  197.         }
  198.         while (fip->field_tag && fip->field_tag < dp->tdir_tag)
  199.             fip++;
  200.         if (!fip->field_tag || fip->field_tag != dp->tdir_tag) {
  201.             TIFFWarning(tif->tif_name,
  202.                 "unknown field with tag %d (0x%x) ignored",
  203.                 dp->tdir_tag,  dp->tdir_tag);
  204.             dp->tdir_tag = IGNORE;
  205.             fip = tiffFieldInfo;    /* restart search */
  206.             continue;
  207.         }
  208.         /*
  209.          * Null out old tags that we ignore.
  210.          */
  211.         if (fip->field_bit == FIELD_IGNORE) {
  212.     ignore:
  213.             dp->tdir_tag = IGNORE;
  214.             continue;
  215.         }
  216.         /*
  217.          * Check data type.
  218.          */
  219.         while (dp->tdir_type != (u_short)fip->field_type) {
  220.             if (fip->field_type == TIFF_ANY)    /* wildcard */
  221.                 break;
  222.             fip++;
  223.             if (!fip->field_tag || fip->field_tag != dp->tdir_tag) {
  224.                 TIFFWarning(tif->tif_name,
  225.                    "wrong data type %d for \"%s\"; tag ignored",
  226.                     dp->tdir_type, fip[-1].field_name);
  227.                 goto ignore;
  228.             }
  229.         }
  230.         /*
  231.          * Check count if known in advance.
  232.          */
  233.         if (fip->field_readcount != TIFF_VARIABLE) {
  234.             uint32 expected = (fip->field_readcount == TIFF_SPP) ?
  235.                 (uint32) td->td_samplesperpixel :
  236.                 (uint32) fip->field_readcount;
  237.             if (!CheckDirCount(tif, dp, expected))
  238.                 goto ignore;
  239.         }
  240.  
  241.         switch (dp->tdir_tag) {
  242.         case TIFFTAG_STRIPOFFSETS:
  243.         case TIFFTAG_STRIPBYTECOUNTS:
  244.         case TIFFTAG_TILEOFFSETS:
  245.         case TIFFTAG_TILEBYTECOUNTS:
  246.             TIFFSetFieldBit(tif, fip->field_bit);
  247.             break;
  248.         case TIFFTAG_IMAGEWIDTH:
  249.         case TIFFTAG_IMAGELENGTH:
  250.         case TIFFTAG_IMAGEDEPTH:
  251.         case TIFFTAG_TILELENGTH:
  252.         case TIFFTAG_TILEWIDTH:
  253.         case TIFFTAG_TILEDEPTH:
  254.         case TIFFTAG_PLANARCONFIG:
  255.         case TIFFTAG_SAMPLESPERPIXEL:
  256.         case TIFFTAG_ROWSPERSTRIP:
  257.             if (!TIFFFetchNormalTag(tif, dp))
  258.                 goto bad;
  259.             dp->tdir_tag = IGNORE;
  260.             break;
  261.         case TIFFTAG_EXTRASAMPLES:
  262.             (void) TIFFFetchExtraSamples(tif, dp);
  263.             dp->tdir_tag = IGNORE;
  264.             break;
  265.         }
  266.     }
  267.  
  268.     /*
  269.      * Allocate directory structure and setup defaults.
  270.      */
  271.     if (!TIFFFieldSet(tif, FIELD_IMAGEDIMENSIONS)) {
  272.         MissingRequired(tif, "ImageLength");
  273.         goto bad;
  274.     }
  275.     if (!TIFFFieldSet(tif, FIELD_PLANARCONFIG)) {
  276.         MissingRequired(tif, "PlanarConfiguration");
  277.         goto bad;
  278.     }
  279.     /* 
  280.       * Setup appropriate structures (by strip or by tile)
  281.      */
  282.     if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) {
  283.         td->td_stripsperimage = (td->td_rowsperstrip == 0xffffffff ?
  284.              (td->td_imagelength != 0 ? 1 : 0) :
  285.              howmany(td->td_imagelength, td->td_rowsperstrip));
  286.         td->td_tilewidth = td->td_imagewidth;
  287.         td->td_tilelength = td->td_rowsperstrip;
  288.         td->td_tiledepth = td->td_imagedepth;
  289.         tif->tif_flags &= ~TIFF_ISTILED;
  290.     } else {
  291.         td->td_stripsperimage = TIFFNumberOfTiles(tif);
  292.         tif->tif_flags |= TIFF_ISTILED;
  293.     }
  294.     td->td_nstrips = td->td_stripsperimage;
  295.     if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
  296.         td->td_nstrips *= td->td_samplesperpixel;
  297.     if (!TIFFFieldSet(tif, FIELD_STRIPOFFSETS)) {
  298.         MissingRequired(tif,
  299.             isTiled(tif) ? "TileOffsets" : "StripOffsets");
  300.         goto bad;
  301.     }
  302.  
  303.     /*
  304.      * Second pass: extract other information.
  305.      */
  306.     for (dp = dir, n = dircount; n > 0; n--, dp++) {
  307.         if (dp->tdir_tag == IGNORE)
  308.             continue;
  309.         switch (dp->tdir_tag) {
  310.         case TIFFTAG_COMPRESSION:
  311.         case TIFFTAG_MINSAMPLEVALUE:
  312.         case TIFFTAG_MAXSAMPLEVALUE:
  313.         case TIFFTAG_BITSPERSAMPLE:
  314.             /*
  315.              * The 5.0 spec says the Compression tag has
  316.              * one value, while earlier specs say it has
  317.              * one value per sample.  Because of this, we
  318.              * accept the tag if one value is supplied.
  319.              *
  320.              * The MinSampleValue, MaxSampleValue and
  321.              * BitsPerSample tags are supposed to be written
  322.              * as one value/sample, but some vendors incorrectly
  323.              * write one value only -- so we accept that
  324.              * as well (yech).
  325.              */
  326.             if (dp->tdir_count == 1) {
  327.                 v = TIFFExtractData(tif,
  328.                     dp->tdir_type, dp->tdir_offset);
  329.                 if (!TIFFSetField(tif, dp->tdir_tag, (int)v))
  330.                     goto bad;
  331.                 break;
  332.             }
  333.             /* fall thru... */
  334.         case TIFFTAG_DATATYPE:
  335.         case TIFFTAG_SAMPLEFORMAT:
  336.             if (!TIFFFetchPerSampleShorts(tif, dp, &iv) ||
  337.                 !TIFFSetField(tif, dp->tdir_tag, iv))
  338.                 goto bad;
  339.             break;
  340.         case TIFFTAG_STRIPOFFSETS:
  341.         case TIFFTAG_TILEOFFSETS:
  342.             if (!TIFFFetchStripThing(tif, dp,
  343.                 td->td_nstrips, &td->td_stripoffset))
  344.                 goto bad;
  345.             break;
  346.         case TIFFTAG_STRIPBYTECOUNTS:
  347.         case TIFFTAG_TILEBYTECOUNTS:
  348.             if (!TIFFFetchStripThing(tif, dp,
  349.                 td->td_nstrips, &td->td_stripbytecount))
  350.                 goto bad;
  351.             break;
  352.         case TIFFTAG_COLORMAP:
  353.         case TIFFTAG_TRANSFERFUNCTION:
  354.             /*
  355.              * TransferFunction can have either 1x or 3x data
  356.              * values; Colormap can have only 3x items.
  357.              */
  358.             v = 1L<<td->td_bitspersample;
  359.             if (dp->tdir_tag == TIFFTAG_COLORMAP ||
  360.                 dp->tdir_count != v) {
  361.                 if (!CheckDirCount(tif, dp, 3*v))
  362.                     break;
  363.             }
  364.             v *= sizeof (uint16);
  365.             cp = CheckMalloc(tif, dp->tdir_count * sizeof (uint16),
  366.                 "to read \"TransferFunction\" tag");
  367.             if (cp != NULL) {
  368.                 if (TIFFFetchData(tif, dp, cp)) {
  369.                     /*
  370.                      * This deals with there being only
  371.                      * one array to apply to all samples.
  372.                      */
  373.                     if (dp->tdir_count == (1L<<td->td_bitspersample))
  374.                         v = 0;
  375.                     TIFFSetField(tif, dp->tdir_tag,
  376.                         cp, cp+v, cp+2*v);
  377.                 }
  378.                 _TIFFfree(cp);
  379.             }
  380.             break;
  381.         case TIFFTAG_PAGENUMBER:
  382.         case TIFFTAG_HALFTONEHINTS:
  383.         case TIFFTAG_YCBCRSUBSAMPLING:
  384.         case TIFFTAG_DOTRANGE:
  385.             (void) TIFFFetchShortPair(tif, dp);
  386.             break;
  387. #ifdef COLORIMETRY_SUPPORT
  388.         case TIFFTAG_REFERENCEBLACKWHITE:
  389.             (void) TIFFFetchRefBlackWhite(tif, dp);
  390.             break;
  391. #endif
  392. #ifdef JPEG_SUPPORT
  393.         case TIFFTAG_JPEGQTABLES:
  394.             if (TIFFFetchJPEGQTables(tif, dp))
  395.                 TIFFSetFieldBit(tif, FIELD_JPEGQTABLES);
  396.             break;
  397.         case TIFFTAG_JPEGDCTABLES:
  398.             if (TIFFFetchJPEGCTables(tif, dp, &td->td_dctab))
  399.                 TIFFSetFieldBit(tif, FIELD_JPEGDCTABLES);
  400.             break;
  401.         case TIFFTAG_JPEGACTABLES:
  402.             if (TIFFFetchJPEGCTables(tif, dp, &td->td_actab))
  403.                 TIFFSetFieldBit(tif, FIELD_JPEGACTABLES);
  404.             break;
  405. #endif
  406. /* BEGIN REV 4.0 COMPATIBILITY */
  407.         case TIFFTAG_OSUBFILETYPE:
  408.             v = 0;
  409.             switch (TIFFExtractData(tif, dp->tdir_type,
  410.                 dp->tdir_offset)) {
  411.             case OFILETYPE_REDUCEDIMAGE:
  412.                 v = FILETYPE_REDUCEDIMAGE;
  413.                 break;
  414.             case OFILETYPE_PAGE:
  415.                 v = FILETYPE_PAGE;
  416.                 break;
  417.             }
  418.             if (v)
  419.                 (void) TIFFSetField(tif,
  420.                     TIFFTAG_SUBFILETYPE, (int)v);
  421.             break;
  422. /* END REV 4.0 COMPATIBILITY */
  423.         default:
  424.             (void) TIFFFetchNormalTag(tif, dp);
  425.             break;
  426.         }
  427.     }
  428.     /*
  429.      * Verify Palette image has a Colormap.
  430.      */
  431.     if (td->td_photometric == PHOTOMETRIC_PALETTE &&
  432.         !TIFFFieldSet(tif, FIELD_COLORMAP)) {
  433.         MissingRequired(tif, "Colormap");
  434.         goto bad;
  435.     }
  436.     /*
  437.      * Attempt to deal with a missing StripByteCounts tag.
  438.      */
  439.     if (!TIFFFieldSet(tif, FIELD_STRIPBYTECOUNTS)) {
  440.         /*
  441.          * Some manufacturers violate the spec by not giving
  442.          * the size of the strips.  In this case, assume there
  443.          * is one uncompressed strip of data.
  444.          */
  445.         if (td->td_nstrips > 1) {
  446.             MissingRequired(tif, "StripByteCounts");
  447.             goto bad;
  448.         }
  449.         TIFFWarning(tif->tif_name,
  450. "TIFF directory is missing required \"%s\" field, calculating from imagelength",
  451.             TIFFFieldWithTag(TIFFTAG_STRIPBYTECOUNTS)->field_name);
  452.         EstimateStripByteCounts(tif, dir, dircount);
  453. #define    BYTECOUNTLOOKSBAD \
  454.     (td->td_stripbytecount[0] == 0 || \
  455.     (td->td_compression == COMPRESSION_NONE && \
  456.      td->td_stripbytecount[0] > TIFFGetFileSize(tif) - td->td_stripoffset[0]))
  457.     } else if (td->td_nstrips == 1 && BYTECOUNTLOOKSBAD) {
  458.         /*
  459.          * Plexus (and others) sometimes give a value
  460.          * of zero for a tag when they don't know what
  461.          * the correct value is!  Try and handle the
  462.          * simple case of estimating the size of a one
  463.          * strip image.
  464.          */
  465.         TIFFWarning(tif->tif_name,
  466.         "Bogus \"%s\" field, ignoring and calculating from imagelength",
  467.             TIFFFieldWithTag(TIFFTAG_STRIPBYTECOUNTS)->field_name);
  468.         EstimateStripByteCounts(tif, dir, dircount);
  469.     }
  470.     if (dir)
  471.         _TIFFfree((char *)dir);
  472.     if (!TIFFFieldSet(tif, FIELD_MAXSAMPLEVALUE))
  473.         td->td_maxsamplevalue = (1L<<td->td_bitspersample)-1;
  474.     /*
  475.      * Setup default compression scheme.
  476.      */
  477.     if (!TIFFFieldSet(tif, FIELD_COMPRESSION))
  478.         TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
  479. #ifdef STRIPCHOP_SUPPORT
  480.         /*
  481.          * Some manufacturers make life difficult by writing
  482.      * large amounts of uncompressed data as a single strip.
  483.      * This is contrary to the recommendations of the spec.
  484.          * The following makes an attempt at breaking such images
  485.      * into strips closer to the recommended 8k bytes.  A
  486.      * side effect, however, is that the RowsPerStrip tag
  487.      * value may be changed.
  488.          */
  489.         if (td->td_nstrips == 1 && td->td_compression == COMPRESSION_NONE &&
  490.         td->td_tilewidth == td->td_imagewidth)
  491.         ChopUpSingleUncompressedStrip(tif);
  492. #endif
  493.     /*
  494.      * Reinitialize i/o since we are starting on a new directory.
  495.      */
  496.     tif->tif_row = -1;
  497.     tif->tif_curstrip = -1;
  498.     tif->tif_col = -1;
  499.     tif->tif_curtile = -1;
  500.     tif->tif_tilesize = TIFFTileSize(tif);
  501.     tif->tif_scanlinesize = TIFFScanlineSize(tif);
  502.     return (1);
  503. bad:
  504.     if (dir)
  505.         _TIFFfree((char *)dir);
  506.     return (0);
  507. }
  508.  
  509. static void
  510. EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount)
  511. {
  512.     register TIFFDirEntry *dp;
  513.     register TIFFDirectory *td = &tif->tif_dir;
  514.  
  515.     td->td_stripbytecount = (uint32*)
  516.         CheckMalloc(tif, sizeof (uint32), "for \"StripByteCounts\" array");
  517.     if (td->td_compression != COMPRESSION_NONE) {
  518.         uint32 space = sizeof (TIFFHeader)
  519.             + sizeof (uint16)
  520.             + (dircount * sizeof (TIFFDirEntry))
  521.             + sizeof (uint32);
  522.         toff_t filesize = TIFFGetFileSize(tif);
  523.         uint16 n;
  524.  
  525.         /* calculate amount of space used by indirect values */
  526.         for (dp = dir, n = dircount; n > 0; n--, dp++) {
  527.             int cc = dp->tdir_count * tiffDataWidth[dp->tdir_type];
  528.             if (cc > sizeof (uint32))
  529.                 space += cc;
  530.         }
  531.         td->td_stripbytecount[0] = filesize - space;
  532.         /*
  533.          * This gross hack handles the case were the offset to
  534.          * the strip is past the place where we think the strip
  535.          * should begin.  Since a strip of data must be contiguous,
  536.          * it's safe to assume that we've overestimated the amount
  537.          * of data in the strip and trim this number back accordingly.
  538.          */ 
  539.         if (td->td_stripoffset[0] + td->td_stripbytecount[0] > filesize)
  540.             td->td_stripbytecount[0] =
  541.                 filesize - td->td_stripoffset[0];
  542.     } else {
  543.         uint32 rowbytes = howmany(td->td_bitspersample *
  544.             td->td_samplesperpixel * td->td_imagewidth, 8);
  545.         td->td_stripbytecount[0] = td->td_imagelength * rowbytes;
  546.     }
  547.     TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS);
  548.     if (!TIFFFieldSet(tif, FIELD_ROWSPERSTRIP))
  549.         td->td_rowsperstrip = td->td_imagelength;
  550. }
  551.  
  552. static void
  553. MissingRequired(TIFF* tif, const char* tagname)
  554. {
  555.     TIFFError(tif->tif_name,
  556.         "TIFF directory is missing required \"%s\" field", tagname);
  557. }
  558.  
  559. /*
  560.  * Check the count field of a directory
  561.  * entry against a known value.  The caller
  562.  * is expected to skip/ignore the tag if
  563.  * there is a mismatch.
  564.  */
  565. static int
  566. CheckDirCount(TIFF* tif, TIFFDirEntry* dir, uint32 count)
  567. {
  568.     if (count != dir->tdir_count) {
  569.         TIFFWarning(tif->tif_name,
  570.     "incorrect count for field \"%s\" (%lu, expecting %lu); tag ignored",
  571.             TIFFFieldWithTag(dir->tdir_tag)->field_name,
  572.             dir->tdir_count, count);
  573.         return (0);
  574.     }
  575.     return (1);
  576. }
  577.  
  578. /*
  579.  * Fetch a contiguous directory item.
  580.  */
  581. static tsize_t
  582. TIFFFetchData(TIFF* tif, TIFFDirEntry* dir, char* cp)
  583. {
  584.     int w = tiffDataWidth[dir->tdir_type];
  585.     tsize_t cc = dir->tdir_count * w;
  586.  
  587.     if (!isMapped(tif)) {
  588.         if (!SeekOK(tif, dir->tdir_offset))
  589.             goto bad;
  590.         if (!ReadOK(tif, cp, cc))
  591.             goto bad;
  592.     } else {
  593.         if (dir->tdir_offset + cc > tif->tif_size)
  594.             goto bad;
  595.         memcpy(cp, tif->tif_base + dir->tdir_offset, cc);
  596.     }
  597.     if (tif->tif_flags & TIFF_SWAB) {
  598.         switch (dir->tdir_type) {
  599.         case TIFF_SHORT:
  600.         case TIFF_SSHORT:
  601.             TIFFSwabArrayOfShort((uint16*)cp, dir->tdir_count);
  602.             break;
  603.         case TIFF_LONG:
  604.         case TIFF_SLONG:
  605.         case TIFF_FLOAT:
  606.             TIFFSwabArrayOfLong((uint32*)cp, dir->tdir_count);
  607.             break;
  608.         case TIFF_RATIONAL:
  609.         case TIFF_SRATIONAL:
  610.             TIFFSwabArrayOfLong((uint32*)cp, 2*dir->tdir_count);
  611.             break;
  612.         }
  613.     }
  614.     return (cc);
  615. bad:
  616.     TIFFError(tif->tif_name, "Error fetching data for field \"%s\"",
  617.         TIFFFieldWithTag(dir->tdir_tag)->field_name);
  618.     return ((tsize_t) 0);
  619. }
  620.  
  621. /*
  622.  * Fetch an ASCII item from the file.
  623.  */
  624. static tsize_t
  625. TIFFFetchString(TIFF* tif, TIFFDirEntry* dir, char* cp)
  626. {
  627.     if (dir->tdir_count <= 4) {
  628.         uint32 l = dir->tdir_offset;
  629.         if (tif->tif_flags & TIFF_SWAB)
  630.             TIFFSwabLong(&l);
  631.         memcpy(cp, &l, dir->tdir_count);
  632.         return (1);
  633.     }
  634.     return (TIFFFetchData(tif, dir, cp));
  635. }
  636.  
  637. /*
  638.  * Convert numerator+denominator to float.
  639.  */
  640. static int
  641. cvtRational(TIFF* tif, TIFFDirEntry* dir, uint32 num, uint32 denom, float* rv)
  642. {
  643.     if (denom == 0) {
  644.         TIFFError(tif->tif_name,
  645.             "%s: Rational with zero denominator (num = %lu)",
  646.             TIFFFieldWithTag(dir->tdir_tag)->field_name, num);
  647.         return (0);
  648.     } else {
  649.         if (dir->tdir_type == TIFF_RATIONAL)
  650.             *rv = ((float)num / (float)denom);
  651.         else
  652.             *rv = ((float)(int32)num / (float)(int32)denom);
  653.         return (1);
  654.     }
  655. }
  656.  
  657. /*
  658.  * Fetch a rational item from the file
  659.  * at offset off and return the value
  660.  * as a floating point number.
  661.  */
  662. static float
  663. TIFFFetchRational(TIFF* tif, TIFFDirEntry* dir)
  664. {
  665.     uint32 l[2];
  666.     float v;
  667.  
  668.     return (!TIFFFetchData(tif, dir, (char *)l) ||
  669.         !cvtRational(tif, dir, l[0], l[1], &v) ? 1. : v);
  670. }
  671.  
  672. /*
  673.  * Fetch a single floating point value
  674.  * from the offset field and return it
  675.  * as a native float.
  676.  */
  677. static float
  678. TIFFFetchFloat(TIFF* tif, TIFFDirEntry* dir)
  679. {
  680.     float v = (float)
  681.         TIFFExtractData(tif, dir->tdir_type, dir->tdir_offset);
  682.     TIFFCvtIEEEFloatToNative(tif, 1, &v);
  683.     return (v);
  684. }
  685.  
  686. /*
  687.  * Fetch an array of BYTE or SBYTE values.
  688.  */
  689. static int
  690. TIFFFetchByteArray(TIFF* tif, TIFFDirEntry* dir, uint16* v)
  691. {
  692.     if (dir->tdir_count <= 4) {
  693.         /*
  694.          * Extract data from offset field.
  695.          */
  696.         if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {
  697.             switch (dir->tdir_count) {
  698.             case 4: v[3] = dir->tdir_offset & 0xff;
  699.             case 3: v[2] = (dir->tdir_offset >> 8) & 0xff;
  700.             case 2: v[1] = (dir->tdir_offset >> 16) & 0xff;
  701.             case 1: v[0] = dir->tdir_offset >> 24;
  702.             }
  703.         } else {
  704.             switch (dir->tdir_count) {
  705.             case 4: v[3] = dir->tdir_offset >> 24;
  706.             case 3: v[2] = (dir->tdir_offset >> 16) & 0xff;
  707.             case 2: v[1] = (dir->tdir_offset >> 8) & 0xff;
  708.             case 1: v[0] = dir->tdir_offset & 0xff;
  709.             }
  710.         }
  711.         return (1);
  712.     } else
  713.         return (TIFFFetchData(tif, dir, (char *)v));    /* XXX */
  714. }
  715.  
  716. /*
  717.  * Fetch an array of SHORT or SSHORT values.
  718.  */
  719. static int
  720. TIFFFetchShortArray(TIFF* tif, TIFFDirEntry* dir, uint16* v)
  721. {
  722.     if (dir->tdir_count <= 2) {
  723.         if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {
  724.             switch (dir->tdir_count) {
  725.             case 2: v[1] = dir->tdir_offset & 0xffff;
  726.             case 1: v[0] = dir->tdir_offset >> 16;
  727.             }
  728.         } else {
  729.             switch (dir->tdir_count) {
  730.             case 2: v[1] = dir->tdir_offset >> 16;
  731.             case 1: v[0] = dir->tdir_offset & 0xffff;
  732.             }
  733.         }
  734.         return (1);
  735.     } else
  736.         return (TIFFFetchData(tif, dir, (char *)v));
  737. }
  738.  
  739. /*
  740.  * Fetch a pair of SHORT or BYTE values.
  741.  */
  742. static int
  743. TIFFFetchShortPair(TIFF* tif, TIFFDirEntry* dir)
  744. {
  745.     uint16 v[2];
  746.     int ok = 0;
  747.  
  748.     switch (dir->tdir_type) {
  749.     case TIFF_SHORT:
  750.     case TIFF_SSHORT:
  751.         ok = TIFFFetchShortArray(tif, dir, v);
  752.         break;
  753.     case TIFF_BYTE:
  754.     case TIFF_SBYTE:
  755.         ok  = TIFFFetchByteArray(tif, dir, v);
  756.         break;
  757.     }
  758.     if (ok)
  759.         TIFFSetField(tif, dir->tdir_tag, v[0], v[1]);
  760.     return (ok);
  761. }
  762.  
  763. /*
  764.  * Fetch an array of LONG or SLONG values.
  765.  */
  766. static int
  767. TIFFFetchLongArray(TIFF* tif, TIFFDirEntry* dir, uint32* v)
  768. {
  769.     if (dir->tdir_count == 1) {
  770.         v[0] = dir->tdir_offset;
  771.         return (1);
  772.     } else
  773.         return (TIFFFetchData(tif, dir, (char *)v));
  774. }
  775.  
  776. /*
  777.  * Fetch an array of RATIONAL or SRATIONAL values.
  778.  */
  779. static int
  780. TIFFFetchRationalArray(TIFF* tif, TIFFDirEntry* dir, float* v)
  781. {
  782.     int ok = 0;
  783.     uint32 *l;
  784.  
  785.     l = (uint32*)CheckMalloc(tif,
  786.         dir->tdir_count*tiffDataWidth[dir->tdir_type],
  787.         "to fetch array of rationals");
  788.     if (l) {
  789.         if (TIFFFetchData(tif, dir, (char *)l)) {
  790.             uint32 i;
  791.             for (i = 0; i < dir->tdir_count; i++) {
  792.                 ok = cvtRational(tif, dir,
  793.                     l[2*i+0], l[2*i+1], &v[i]);
  794.                 if (!ok)
  795.                     break;
  796.             }
  797.         }
  798.         _TIFFfree((char *)l);
  799.     }
  800.     return (ok);
  801. }
  802.  
  803. /*
  804.  * Fetch an array of FLOAT values.
  805.  */
  806. static int
  807. TIFFFetchFloatArray(TIFF* tif, TIFFDirEntry* dir, float* v)
  808. {
  809.     if (TIFFFetchData(tif, dir, (char *)v)) {
  810.         TIFFCvtIEEEFloatToNative(tif, dir->tdir_count, v);
  811.         return (1);
  812.     } else
  813.         return (0);
  814. }
  815.  
  816. /*
  817.  * Fetch a tag that is not handled by special case code.
  818.  *
  819.  * NB: DOUBLE and UNDEFINED types are not handled.
  820.  */
  821. static int
  822. TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp)
  823. {
  824.     static char mesg[] = "to fetch tag value";
  825.     int ok = 0;
  826.  
  827.     if (dp->tdir_count > 1) {        /* array of values */
  828.         char* cp = NULL;
  829.  
  830.         switch (dp->tdir_type) {
  831.         case TIFF_BYTE:
  832.         case TIFF_SBYTE:
  833.             /* NB: always expand BYTE values to shorts */
  834.             cp = CheckMalloc(tif,
  835.                 dp->tdir_count * sizeof (uint16), mesg);
  836.             ok = cp && TIFFFetchByteArray(tif, dp, (uint16*)cp);
  837.             break;
  838.         case TIFF_SHORT:
  839.         case TIFF_SSHORT:
  840.             cp = CheckMalloc(tif,
  841.                 dp->tdir_count * sizeof (uint16), mesg);
  842.             ok = cp && TIFFFetchShortArray(tif, dp, (uint16*)cp);
  843.             break;
  844.         case TIFF_LONG:
  845.         case TIFF_SLONG:
  846.             cp = CheckMalloc(tif,
  847.                 dp->tdir_count * sizeof (uint32), mesg);
  848.             ok = cp && TIFFFetchLongArray(tif, dp, (uint32*)cp);
  849.             break;
  850.         case TIFF_RATIONAL:
  851.         case TIFF_SRATIONAL:
  852.             cp = CheckMalloc(tif,
  853.                 dp->tdir_count * sizeof (float), mesg);
  854.             ok = cp && TIFFFetchRationalArray(tif, dp, (float *)cp);
  855.             break;
  856.         case TIFF_FLOAT:
  857.             cp = CheckMalloc(tif,
  858.                 dp->tdir_count * sizeof (float), mesg);
  859.             ok = cp && TIFFFetchFloatArray(tif, dp, (float *)cp);
  860.             break;
  861.         case TIFF_ASCII:
  862.             /*
  863.              * Some vendors write strings w/o the trailing
  864.              * NULL byte, so always append one just in case.
  865.              */
  866.             cp = CheckMalloc(tif, dp->tdir_count+1, mesg);
  867.             if (ok = (cp && TIFFFetchString(tif, dp, cp)))
  868.                 cp[dp->tdir_count] = '\0';    /* XXX */
  869.             break;
  870.         }
  871.         if (ok)
  872.             ok = TIFFSetField(tif, dp->tdir_tag, cp);
  873.         if (cp != NULL)
  874.             _TIFFfree(cp);
  875.     } else if (CheckDirCount(tif, dp, 1)) {    /* singleton value */
  876.         char c[2];
  877.         TIFFDataType type;
  878.         switch (dp->tdir_type) {
  879.         case TIFF_BYTE:
  880.         case TIFF_SBYTE:
  881.         case TIFF_SHORT:
  882.         case TIFF_SSHORT:
  883.             /*
  884.              * If the tag is also acceptable as a LONG or SLONG
  885.              * then TIFFSetField will expect an uint32 parameter
  886.              * passed to it (through varargs).  Thus, for machines
  887.              * where sizeof (int) != sizeof (uint32) we must do
  888.              * a careful check here.  It's hard to say if this
  889.              * is worth optimizing.
  890.              *
  891.              * NB: We use TIFFFieldWithTag here knowing that
  892.              *     it returns us the first entry in the table
  893.              *     for the tag and that that entry is for the
  894.              *     widest potential data type the tag may have.
  895.              */
  896.             type = TIFFFieldWithTag(dp->tdir_tag)->field_type;
  897.             if (type != TIFF_LONG && type != TIFF_SLONG) {
  898.                 ok = TIFFSetField(tif, dp->tdir_tag, (int)
  899.               TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset));
  900.                 break;
  901.             }
  902.             /* fall thru... */
  903.         case TIFF_LONG:
  904.         case TIFF_SLONG:
  905.             ok = TIFFSetField(tif, dp->tdir_tag, (uint32)
  906.           TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset));
  907.             break;
  908.         case TIFF_RATIONAL:
  909.         case TIFF_SRATIONAL:
  910.             ok = TIFFSetField(tif, dp->tdir_tag,
  911.                 TIFFFetchRational(tif, dp));
  912.             break;
  913.         case TIFF_FLOAT:
  914.             ok = TIFFSetField(tif, dp->tdir_tag,
  915.                 TIFFFetchFloat(tif, dp));
  916.             break;
  917.         case TIFF_ASCII:
  918.             if (ok = (TIFFFetchString(tif, dp, c))) {
  919.                 c[1] = '\0';        /* XXX paranoid */
  920.                 ok = TIFFSetField(tif, dp->tdir_tag, c);
  921.             }
  922.             break;
  923.         }
  924.     }
  925.     return (ok);
  926. }
  927.  
  928. #define    NITEMS(x)    (sizeof (x) / sizeof (x[0]))
  929. /*
  930.  * Fetch samples/pixel short values for 
  931.  * the specified tag and verify that
  932.  * all values are the same.
  933.  */
  934. static int
  935. TIFFFetchPerSampleShorts(TIFF* tif, TIFFDirEntry* dir, int* pl)
  936. {
  937.     int samples = tif->tif_dir.td_samplesperpixel;
  938.     int status = 0;
  939.  
  940.     if (CheckDirCount(tif, dir, (uint32) samples)) {
  941.         uint16 buf[10];
  942.         uint16* v = buf;
  943.  
  944.         if (samples > NITEMS(buf))
  945.             v = (uint16*)_TIFFmalloc(samples * sizeof (uint16));
  946.         if (TIFFFetchShortArray(tif, dir, v)) {
  947.             int i;
  948.             for (i = 1; i < samples; i++)
  949.                 if (v[i] != v[0]) {
  950.                     TIFFError(tif->tif_name,
  951.         "Cannot handle different per-sample values for field \"%s\"",
  952.                    TIFFFieldWithTag(dir->tdir_tag)->field_name);
  953.                     goto bad;
  954.                 }
  955.             *pl = v[0];
  956.             status = 1;
  957.         }
  958.     bad:
  959.         if (v != buf)
  960.             _TIFFfree((char *)v);
  961.     }
  962.     return (status);
  963. }
  964. #undef NITEMS
  965.  
  966. /*
  967.  * Fetch a set of offsets or lengths.
  968.  * While this routine says "strips",
  969.  * in fact it's also used for tiles.
  970.  */
  971. static int
  972. TIFFFetchStripThing(TIFF* tif, TIFFDirEntry* dir, long nstrips, uint32** lpp)
  973. {
  974.     register uint32 *lp;
  975.     int status;
  976.  
  977.     if (!CheckDirCount(tif, dir, nstrips))
  978.         return (0);
  979.     /*
  980.      * Allocate space for strip information.
  981.      */
  982.     if (*lpp == NULL &&
  983.         (*lpp = (uint32 *)CheckMalloc(tif,
  984.           nstrips * sizeof (uint32), "for strip array")) == NULL)
  985.         return (0);
  986.     lp = *lpp;
  987.     if (dir->tdir_type == (int)TIFF_SHORT) {
  988.         /*
  989.          * Handle uint16->uint32 expansion.
  990.          */
  991.         uint16 *dp = (uint16 *)CheckMalloc(tif,
  992.             dir->tdir_count* sizeof (uint16), "to fetch strip tag");
  993.         if (dp == NULL)
  994.             return (0);
  995.         if (status = TIFFFetchShortArray(tif, dir, dp)) {
  996.             register uint16 *wp = dp;
  997.             while (nstrips-- > 0)
  998.                 *lp++ = *wp++;
  999.         }
  1000.         _TIFFfree((char *)dp);
  1001.     } else
  1002.         status = TIFFFetchLongArray(tif, dir, lp);
  1003.     return (status);
  1004. }
  1005.  
  1006. #define    NITEMS(x)    (sizeof (x) / sizeof (x[0]))
  1007. /*
  1008.  * Fetch and set the ExtraSamples tag.
  1009.  */
  1010. static int
  1011. TIFFFetchExtraSamples(TIFF* tif, TIFFDirEntry* dir)
  1012. {
  1013.     uint16 buf[10], *v = buf;
  1014.     int status;
  1015.  
  1016.     if (dir->tdir_count > NITEMS(buf))
  1017.         v = (uint16*)_TIFFmalloc(dir->tdir_count * sizeof (uint16));
  1018.     if (dir->tdir_type == TIFF_BYTE)
  1019.         status = TIFFFetchByteArray(tif, dir, v);
  1020.     else
  1021.         status = TIFFFetchShortArray(tif, dir, v);
  1022.     if (status)
  1023.         status = TIFFSetField(tif, dir->tdir_tag, dir->tdir_count, v);
  1024.     if (v != buf)
  1025.         _TIFFfree((char *)v);
  1026.     return (status);
  1027. }
  1028. #undef NITEMS
  1029.  
  1030. #ifdef COLORIMETRY_SUPPORT
  1031. /*
  1032.  * Fetch and set the RefBlackWhite tag.
  1033.  */
  1034. static int
  1035. TIFFFetchRefBlackWhite(TIFF* tif, TIFFDirEntry* dir)
  1036. {
  1037.     static char mesg[] = "for \"ReferenceBlackWhite\" array";
  1038.     char* cp;
  1039.     int ok;
  1040.  
  1041.     if (dir->tdir_type == TIFF_RATIONAL)
  1042.         return (TIFFFetchNormalTag(tif, dir));
  1043.     /*
  1044.      * Handle LONG's for backward compatibility.
  1045.      */
  1046.     cp = CheckMalloc(tif, dir->tdir_count * sizeof (uint32), mesg);
  1047.     if (ok = (cp && TIFFFetchLongArray(tif, dir, (uint32*)cp))) {
  1048.         float *fp = (float *)
  1049.             CheckMalloc(tif, dir->tdir_count * sizeof (float), mesg);
  1050.         if (ok = (fp != NULL)) {
  1051.             int i;
  1052.             for (i = 0; i < dir->tdir_count; i++)
  1053.                 fp[i] = (float)((uint32*)cp)[i];
  1054.             ok = TIFFSetField(tif, dir->tdir_tag, fp);
  1055.             _TIFFfree((char *)fp);
  1056.         }
  1057.     }
  1058.     if (cp)
  1059.         _TIFFfree(cp);
  1060.     return (ok);
  1061. }
  1062. #endif
  1063.  
  1064. #ifdef JPEG_SUPPORT
  1065. /*
  1066.  * Fetch the JPEG Quantization tables
  1067.  * for the specified directory entry.
  1068.  * Storage for the td_qtab array is
  1069.  * allocated as a side effect.
  1070.  */
  1071. static int
  1072. TIFFFetchJPEGQTables(TIFF* tif, TIFFDirEntry* dir)
  1073. {
  1074.     TIFFDirectory *td = &tif->tif_dir;
  1075.     uint32 off[4];
  1076.     int i, j;
  1077.     TIFFDirEntry tdir;
  1078.     char *qmat;
  1079.  
  1080.     if (dir->tdir_count > 1) {
  1081.         /* XXX verify count <= 4 */
  1082.         if (!TIFFFetchData(tif, dir, (char *)off))
  1083.             return (0);
  1084.     } else
  1085.         off[0] = dir->tdir_offset;
  1086.     /*
  1087.      * We don't share per-component q matrices because
  1088.      * (besides complicating this logic even more), it
  1089.      * would make it very painful if the user does a ``set''.
  1090.      */
  1091.     td->td_qtab = (u_char **)CheckMalloc(tif,
  1092.         dir->tdir_count*(sizeof (u_char *) + 64*sizeof (u_char)),
  1093.         "for JPEG Q table");
  1094.     if (td->td_qtab == NULL)
  1095.         return (0);
  1096.     tdir.tdir_type = TIFF_BYTE;
  1097.     tdir.tdir_count = 64;
  1098.     qmat = (((char *)td->td_qtab) + dir->tdir_count*sizeof (u_char *));
  1099.     for (i = 0; i < dir->tdir_count; i++) {
  1100.         td->td_qtab[i] = (u_char *)qmat;
  1101.         tdir.tdir_offset = off[i];
  1102.         if (!TIFFFetchData(tif, &tdir, qmat))
  1103.             return (0);
  1104.         qmat += 64*sizeof (u_char);
  1105.     }
  1106.     return (1);
  1107. }
  1108.  
  1109. /*
  1110.  * Fetch JPEG Huffman code tables for the
  1111.  * specified directory entry.  Storage for
  1112.  * the tables are allocated as a side effect.
  1113.  */
  1114. static int
  1115. TIFFFetchJPEGCTables(TIFF* tif, TIFFDirEntry* dir, u_char*** ptab)
  1116. {
  1117.     uint32 off[4];
  1118.     int i, j, ncodes;
  1119.     TIFFDirEntry tdir;
  1120.     char *tab;
  1121.  
  1122.     if (dir->tdir_count > 1) {
  1123.         /* XXX verify count <= 4 */
  1124.         if (!TIFFFetchData(tif, dir, (char *)off))
  1125.             return (0);
  1126.     } else
  1127.         off[0] = dir->tdir_offset;
  1128.     /*
  1129.      * We don't share per-component tables because
  1130.      * (besides complicating this logic even more), it
  1131.      * would make it very painful if the user does a
  1132.      * ``set''.  Note also that we don't try to optimize
  1133.      * storage of the tables -- we just allocate enough
  1134.      * space to hold the largest possible.  All this
  1135.      * stuff is so complicated 'cuz the tag is defined
  1136.      * to be compatible with the JPEG table format,
  1137.      * rather than something that fits well into the
  1138.      * structure of TIFF -- argh!
  1139.      */
  1140.     *ptab = (u_char **)CheckMalloc(tif, dir->tdir_count*
  1141.         (sizeof (u_char *) + (16+256)*sizeof (u_char)),
  1142.         "for JPEG Huffman table");
  1143.     if (*ptab == NULL)
  1144.         return (0);
  1145.     tdir.tdir_type = TIFF_BYTE;
  1146.     tab = (((char *)*ptab) + dir->tdir_count*sizeof (u_char *));
  1147.     for (i = 0; i < dir->tdir_count; i++) {
  1148.         (*ptab)[i] = (u_char *)tab;
  1149.         tdir.tdir_offset = off[i];
  1150.         tdir.tdir_count = 16;
  1151.         /*
  1152.          * We must fetch the array that holds the
  1153.          * count of codes for each bit length first
  1154.          * and the count up the number of codes that
  1155.          * are in the variable length table.  This
  1156.          * information is implicit in the JPEG format
  1157.          * 'cuz it's preceded by a length field.
  1158.          */
  1159.         if (!TIFFFetchData(tif, &tdir, tab))    /* count array */
  1160.             return (0);
  1161.         for (ncodes = 0, j = 0; j < 16; j++)
  1162.             ncodes += tab[j];
  1163.         /*
  1164.          * Adjust offsets and fetch codes separately.
  1165.          */
  1166.         tdir.tdir_offset += 16;
  1167.         tdir.tdir_count = ncodes;
  1168.         tab += 16;
  1169.         if (!TIFFFetchData(tif, &tdir, tab))
  1170.             return (0);
  1171.         tab += ncodes;
  1172.     }
  1173.     return (1);
  1174. }
  1175. #endif
  1176.  
  1177. #ifdef STRIPCHOP_SUPPORT
  1178. /*
  1179.  * Replace a single strip (tile) of uncompressed data by
  1180.  * multiple strips (tiles), each approximately 8Kbytes.
  1181.  * This is useful for dealing with large images or
  1182.  * for dealing with machines with a limited amount
  1183.  * memory.
  1184.  */
  1185. static void
  1186. ChopUpSingleUncompressedStrip(TIFF* tif)
  1187. {
  1188.     register TIFFDirectory *td = &tif->tif_dir;
  1189.     uint32 bytecount = td->td_stripbytecount[0];
  1190.     uint32 offset = td->td_stripoffset[0];
  1191.     tsize_t rowbytes = TIFFVTileSize(tif, 1), stripbytes;
  1192.     tstrip_t strip, nstrips, rowsperstrip;
  1193.     uint32* newcounts;
  1194.     uint32* newoffsets;
  1195.  
  1196.     /*
  1197.      * Make the rows hold at least one
  1198.      * scanline, but fill 8k if possible.
  1199.      */
  1200.     if (rowbytes > 8192) {
  1201.         stripbytes = rowbytes;
  1202.         rowsperstrip = 1;
  1203.     } else {
  1204.         rowsperstrip = 8192 / rowbytes;
  1205.         stripbytes = rowbytes * rowsperstrip;
  1206.     }
  1207.     nstrips = howmany(bytecount, stripbytes);
  1208.     newcounts = (uint32*) CheckMalloc(tif, nstrips * sizeof (uint32),
  1209.                 "for chopped \"StripByteCounts\" array");
  1210.     newoffsets = (uint32*) CheckMalloc(tif, nstrips * sizeof (uint32),
  1211.                 "for chopped \"StripOffsets\" array");
  1212.     if (newcounts == NULL || newoffsets == NULL) {
  1213.             /*
  1214.          * Unable to allocate new strip information, give
  1215.          * up and use the original one strip information.
  1216.          */
  1217.         if (newcounts != NULL)
  1218.             _TIFFfree(newcounts);
  1219.         if (newoffsets != NULL)
  1220.             _TIFFfree(newoffsets);
  1221.         return;
  1222.     }
  1223.     /*
  1224.      * Fill the strip information arrays with
  1225.      * new bytecounts and offsets that reflect
  1226.      * the broken-up format.
  1227.      */
  1228.     for (strip = 0; strip < nstrips; strip++) {
  1229.         if (stripbytes > bytecount)
  1230.             stripbytes = bytecount;
  1231.         newcounts[strip] = stripbytes;
  1232.         newoffsets[strip] = offset;
  1233.         offset += stripbytes;
  1234.         bytecount -= stripbytes;
  1235.     }
  1236.     /*
  1237.      * Replace old single strip info with multi-strip info.
  1238.      */
  1239.     td->td_stripsperimage = td->td_nstrips = nstrips;
  1240.     td->td_rowsperstrip = rowsperstrip;
  1241.     td->td_tilelength = rowsperstrip;
  1242.  
  1243.     _TIFFfree(td->td_stripbytecount);
  1244.     _TIFFfree(td->td_stripoffset);
  1245.     td->td_stripbytecount = newcounts;
  1246.     td->td_stripoffset = newoffsets;
  1247. }
  1248. #endif /* STRIPCHOP_SUPPORT */
  1249.